1. Technical Field
The present invention relates to a system and method for supporting for atomic transactions, and more particularly to a system and method for reservation required transactions (RRT).
2. Description of Related Art
Atomic transactions have been widely used in parallel computing and transaction processing. An atomic transaction generally refers to the execution of multiple operations, such that the multiple operations appear to be executed together without any intervening operations. For example, if a memory address is accessed within an atomic transaction, the memory address should not be modified elsewhere until the atomic transaction completes. Thus, if a processor (or a thread in a multithreading environment) uses an atomic transaction to access a set of memory addresses, the atomic transaction semantics should guarantee that another processor (or another thread) cannot modify any of the memory addresses throughout the execution of the atomic transaction.
Atomic transactions can be implemented at architecture level via proper architecture and micro-architecture support, rather than at software level via semaphores and synchronization instructions. Architecture-level atomic transactions can potentially improve overall performance using speculative executions of atomic transactions as well as elimination of semaphore uses. Furthermore, architecture-level atomic transactions can improve productivity because programmers no longer need to worry about using semaphores to achieve desired atomicity semantics.
Supporting atomic transactions architecturally often requires expensive hardware and software enhancements, such as large on-chip buffers for data of uncommitted atomic transactions, and software-managed memory regions for on-chip buffer overflows. Various architecture mechanisms supporting atomic transactions have been proposed. Architecture support of atomic transactions needs to provide conflict detection between atomic transactions, and data buffering for uncommitted atomic transactions. Conflict between different atomic transactions accessing same memory locations is usually detected by hardware on-the-fly. This can be achieved with reasonable implementation cost and complexity because the underlying cache coherence mechanism of the system can be used. However, it can be quite challenging to buffer data for uncommitted transactions with reasonable cost and complexity, if an atomic transaction can modify a large number of memory locations that cannot fit in an on-chip buffer (either a dedicated buffer or on-chip L1/L2 caches).
Existing architecture support of atomic transactions either requires that an atomic transaction ensure buffer overflow cannot happen, or fall back to some software solution when buffer overflow happens. The first approach inevitably limits the use of atomic transactions. The second approach often requires software to acquire some semaphore such as a global lock (that protects the whole address space) to ensure atomicity of memory accesses. It should be noted that when a thread is using a semaphore to protect a memory region, other threads accessing the memory region must use the same semaphore to ensure mutual exclusion. This hardware-software approach of handling buffer overflow is often inefficient and complex.
Therefore, a need exists for a system and method for reservation required transactions.